// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/cubefs/cubefs/blobstore/common/rpc (interfaces: Client)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	http "net/http"
	reflect "reflect"

	rpc "github.com/cubefs/cubefs/blobstore/common/rpc"
	gomock "github.com/golang/mock/gomock"
)

// MockRPCClient is a mock of Client interface.
type MockRPCClient struct {
	ctrl     *gomock.Controller
	recorder *MockRPCClientMockRecorder
}

// MockRPCClientMockRecorder is the mock recorder for MockRPCClient.
type MockRPCClientMockRecorder struct {
	mock *MockRPCClient
}

// NewMockRPCClient creates a new mock instance.
func NewMockRPCClient(ctrl *gomock.Controller) *MockRPCClient {
	mock := &MockRPCClient{ctrl: ctrl}
	mock.recorder = &MockRPCClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRPCClient) EXPECT() *MockRPCClientMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockRPCClient) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockRPCClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRPCClient)(nil).Close))
}

// Delete mocks base method.
func (m *MockRPCClient) Delete(arg0 context.Context, arg1 string) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockRPCClientMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRPCClient)(nil).Delete), arg0, arg1)
}

// Do mocks base method.
func (m *MockRPCClient) Do(arg0 context.Context, arg1 *http.Request) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Do", arg0, arg1)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Do indicates an expected call of Do.
func (mr *MockRPCClientMockRecorder) Do(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockRPCClient)(nil).Do), arg0, arg1)
}

// DoWith mocks base method.
func (m *MockRPCClient) DoWith(arg0 context.Context, arg1 *http.Request, arg2 interface{}, arg3 ...rpc.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DoWith", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DoWith indicates an expected call of DoWith.
func (mr *MockRPCClientMockRecorder) DoWith(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoWith", reflect.TypeOf((*MockRPCClient)(nil).DoWith), varargs...)
}

// Form mocks base method.
func (m *MockRPCClient) Form(arg0 context.Context, arg1, arg2 string, arg3 map[string][]string) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Form", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Form indicates an expected call of Form.
func (mr *MockRPCClientMockRecorder) Form(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Form", reflect.TypeOf((*MockRPCClient)(nil).Form), arg0, arg1, arg2, arg3)
}

// Get mocks base method.
func (m *MockRPCClient) Get(arg0 context.Context, arg1 string) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockRPCClientMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRPCClient)(nil).Get), arg0, arg1)
}

// GetWith mocks base method.
func (m *MockRPCClient) GetWith(arg0 context.Context, arg1 string, arg2 interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWith", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetWith indicates an expected call of GetWith.
func (mr *MockRPCClientMockRecorder) GetWith(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWith", reflect.TypeOf((*MockRPCClient)(nil).GetWith), arg0, arg1, arg2)
}

// Head mocks base method.
func (m *MockRPCClient) Head(arg0 context.Context, arg1 string) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Head", arg0, arg1)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Head indicates an expected call of Head.
func (mr *MockRPCClientMockRecorder) Head(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockRPCClient)(nil).Head), arg0, arg1)
}

// Post mocks base method.
func (m *MockRPCClient) Post(arg0 context.Context, arg1 string, arg2 interface{}) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Post", arg0, arg1, arg2)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Post indicates an expected call of Post.
func (mr *MockRPCClientMockRecorder) Post(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockRPCClient)(nil).Post), arg0, arg1, arg2)
}

// PostWith mocks base method.
func (m *MockRPCClient) PostWith(arg0 context.Context, arg1 string, arg2, arg3 interface{}, arg4 ...rpc.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostWith", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PostWith indicates an expected call of PostWith.
func (mr *MockRPCClientMockRecorder) PostWith(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostWith", reflect.TypeOf((*MockRPCClient)(nil).PostWith), varargs...)
}

// Put mocks base method.
func (m *MockRPCClient) Put(arg0 context.Context, arg1 string, arg2 interface{}) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Put indicates an expected call of Put.
func (mr *MockRPCClientMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockRPCClient)(nil).Put), arg0, arg1, arg2)
}

// PutWith mocks base method.
func (m *MockRPCClient) PutWith(arg0 context.Context, arg1 string, arg2, arg3 interface{}, arg4 ...rpc.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutWith", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutWith indicates an expected call of PutWith.
func (mr *MockRPCClientMockRecorder) PutWith(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWith", reflect.TypeOf((*MockRPCClient)(nil).PutWith), varargs...)
}
